/****************************************************************
 * Fulguro
 * Copyright (C) 2004 Christophe Clienti
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 ***************************************************************/

#ifdef __cplusplus
extern "C" {
#endif


#ifndef __FLGR_CORE_MEASURE_VECTOR_H
#define __FLGR_CORE_MEASURE_VECTOR_H

#include <flgrCoreDll.h>
#include <flgrCoreTypes.h>
#include <flgrCoreErrors.h>
#include <flgrCoreVector.h>

  fgUINT32 flgr_vector_measure_volume_u32(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_volume_s32(FLGR_Vector *vec);

  fgUINT64 flgr_vector_measure_volume_u64(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_volume_s64(FLGR_Vector *vec);
 
  fgFLOAT64 flgr_vector_measure_volume_f64(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_volume_f32(FLGR_Vector *vec);
 
  FLGR_Ret flgr_vector_measure_max(FLGR_Vector *vec, void *max);
  FLGR_Ret flgr_vector_measure_min(FLGR_Vector *vec, void *min);

  fgUINT32 flgr_vector_measure_norm_u32(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_norm_s32(FLGR_Vector *vec);

  fgUINT64 flgr_vector_measure_norm_u64(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_norm_s64(FLGR_Vector *vec);
 
  fgFLOAT64 flgr_vector_measure_norm_f64(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_norm_f32(FLGR_Vector *vec);
 
  FLGR_Ret flgr_vector_measure_max(FLGR_Vector *vec, void *max);
  FLGR_Ret flgr_vector_measure_min(FLGR_Vector *vec, void *min);




  fgUINT64 flgr_vector_measure_norm_u64_fgBIT(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_norm_u64_fgUINT8(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_norm_u64_fgUINT16(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_norm_u64_fgUINT32(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_norm_u64_fgUINT64(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_norm_u64_fgINT8(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_norm_u64_fgINT16(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_norm_u64_fgINT32(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_norm_u64_fgINT64(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_norm_u64_fgFLOAT32(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_norm_u64_fgFLOAT64(FLGR_Vector *vec);

  fgINT64 flgr_vector_measure_norm_s64_fgBIT(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_norm_s64_fgUINT8(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_norm_s64_fgUINT16(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_norm_s64_fgUINT32(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_norm_s64_fgUINT64(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_norm_s64_fgINT8(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_norm_s64_fgINT16(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_norm_s64_fgINT32(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_norm_s64_fgINT64(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_norm_s64_fgFLOAT32(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_norm_s64_fgFLOAT64(FLGR_Vector *vec);

  fgUINT32 flgr_vector_measure_norm_u32_fgBIT(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_norm_u32_fgUINT8(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_norm_u32_fgUINT16(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_norm_u32_fgUINT32(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_norm_u32_fgUINT64(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_norm_u32_fgINT8(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_norm_u32_fgINT16(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_norm_u32_fgINT32(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_norm_u32_fgINT64(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_norm_u32_fgFLOAT32(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_norm_u32_fgFLOAT64(FLGR_Vector *vec);

  fgINT32 flgr_vector_measure_norm_s32_fgBIT(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_norm_s32_fgUINT8(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_norm_s32_fgUINT16(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_norm_s32_fgUINT32(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_norm_s32_fgUINT64(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_norm_s32_fgINT8(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_norm_s32_fgINT16(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_norm_s32_fgINT32(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_norm_s32_fgINT64(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_norm_s32_fgFLOAT32(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_norm_s32_fgFLOAT64(FLGR_Vector *vec);

  fgFLOAT32 flgr_vector_measure_norm_f32_fgBIT(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_norm_f32_fgUINT8(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_norm_f32_fgUINT16(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_norm_f32_fgUINT32(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_norm_f32_fgUINT64(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_norm_f32_fgINT8(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_norm_f32_fgINT16(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_norm_f32_fgINT32(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_norm_f32_fgINT64(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_norm_f32_fgFLOAT32(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_norm_f32_fgFLOAT64(FLGR_Vector *vec);

  fgFLOAT64 flgr_vector_measure_norm_f64_fgBIT(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_norm_f64_fgUINT8(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_norm_f64_fgUINT16(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_norm_f64_fgUINT32(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_norm_f64_fgUINT64(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_norm_f64_fgINT8(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_norm_f64_fgINT16(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_norm_f64_fgINT32(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_norm_f64_fgINT64(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_norm_f64_fgFLOAT32(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_norm_f64_fgFLOAT64(FLGR_Vector *vec);

  fgUINT64 flgr_vector_measure_volume_u64_fgBIT(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_volume_u64_fgUINT8(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_volume_u64_fgUINT16(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_volume_u64_fgUINT32(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_volume_u64_fgUINT64(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_volume_u64_fgINT8(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_volume_u64_fgINT16(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_volume_u64_fgINT32(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_volume_u64_fgINT64(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_volume_u64_fgFLOAT32(FLGR_Vector *vec);
  fgUINT64 flgr_vector_measure_volume_u64_fgFLOAT64(FLGR_Vector *vec);

  fgINT64 flgr_vector_measure_volume_s64_fgBIT(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_volume_s64_fgUINT8(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_volume_s64_fgUINT16(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_volume_s64_fgUINT32(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_volume_s64_fgUINT64(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_volume_s64_fgINT8(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_volume_s64_fgINT16(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_volume_s64_fgINT32(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_volume_s64_fgINT64(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_volume_s64_fgFLOAT32(FLGR_Vector *vec);
  fgINT64 flgr_vector_measure_volume_s64_fgFLOAT64(FLGR_Vector *vec);

  fgUINT32 flgr_vector_measure_volume_u32_fgBIT(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_volume_u32_fgUINT8(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_volume_u32_fgUINT16(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_volume_u32_fgUINT32(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_volume_u32_fgUINT64(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_volume_u32_fgINT8(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_volume_u32_fgINT16(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_volume_u32_fgINT32(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_volume_u32_fgINT64(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_volume_u32_fgFLOAT32(FLGR_Vector *vec);
  fgUINT32 flgr_vector_measure_volume_u32_fgFLOAT64(FLGR_Vector *vec);

  fgINT32 flgr_vector_measure_volume_s32_fgBIT(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_volume_s32_fgUINT8(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_volume_s32_fgUINT16(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_volume_s32_fgUINT32(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_volume_s32_fgUINT64(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_volume_s32_fgINT8(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_volume_s32_fgINT16(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_volume_s32_fgINT32(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_volume_s32_fgINT64(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_volume_s32_fgFLOAT32(FLGR_Vector *vec);
  fgINT32 flgr_vector_measure_volume_s32_fgFLOAT64(FLGR_Vector *vec);

  fgFLOAT32 flgr_vector_measure_volume_f32_fgBIT(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_volume_f32_fgUINT8(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_volume_f32_fgUINT16(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_volume_f32_fgUINT32(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_volume_f32_fgUINT64(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_volume_f32_fgINT8(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_volume_f32_fgINT16(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_volume_f32_fgINT32(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_volume_f32_fgINT64(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_volume_f32_fgFLOAT32(FLGR_Vector *vec);
  fgFLOAT32 flgr_vector_measure_volume_f32_fgFLOAT64(FLGR_Vector *vec);

  fgFLOAT64 flgr_vector_measure_volume_f64_fgBIT(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_volume_f64_fgUINT8(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_volume_f64_fgUINT16(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_volume_f64_fgUINT32(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_volume_f64_fgUINT64(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_volume_f64_fgINT8(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_volume_f64_fgINT16(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_volume_f64_fgINT32(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_volume_f64_fgINT64(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_volume_f64_fgFLOAT32(FLGR_Vector *vec);
  fgFLOAT64 flgr_vector_measure_volume_f64_fgFLOAT64(FLGR_Vector *vec);


  void flgr_vector_measure_min_fgBIT(FLGR_Vector *vec, fgBIT *min);
  void flgr_vector_measure_min_fgUINT8(FLGR_Vector *vec, fgUINT8 *min);
  void flgr_vector_measure_min_fgUINT16(FLGR_Vector *vec, fgUINT16 *min);
  void flgr_vector_measure_min_fgUINT32(FLGR_Vector *vec, fgUINT32 *min);
  void flgr_vector_measure_min_fgUINT64(FLGR_Vector *vec, fgUINT64 *min);
  void flgr_vector_measure_min_fgINT8(FLGR_Vector *vec, fgINT8 *min);
  void flgr_vector_measure_min_fgINT16(FLGR_Vector *vec, fgINT16 *min);
  void flgr_vector_measure_min_fgINT32(FLGR_Vector *vec, fgINT32 *min);
  void flgr_vector_measure_min_fgINT64(FLGR_Vector *vec, fgINT64 *min);
  void flgr_vector_measure_min_fgFLOAT32(FLGR_Vector *vec, fgFLOAT32 *min);
  void flgr_vector_measure_min_fgFLOAT64(FLGR_Vector *vec, fgFLOAT64 *min);

  void flgr_vector_measure_max_fgBIT(FLGR_Vector *vec, fgBIT *max);
  void flgr_vector_measure_max_fgUINT8(FLGR_Vector *vec, fgUINT8 *max);
  void flgr_vector_measure_max_fgUINT16(FLGR_Vector *vec, fgUINT16 *max);
  void flgr_vector_measure_max_fgUINT32(FLGR_Vector *vec, fgUINT32 *max);
  void flgr_vector_measure_max_fgUINT64(FLGR_Vector *vec, fgUINT64 *max);
  void flgr_vector_measure_max_fgINT8(FLGR_Vector *vec, fgINT8 *max);
  void flgr_vector_measure_max_fgINT16(FLGR_Vector *vec, fgINT16 *max);
  void flgr_vector_measure_max_fgINT32(FLGR_Vector *vec, fgINT32 *max);
  void flgr_vector_measure_max_fgINT64(FLGR_Vector *vec, fgINT64 *max);
  void flgr_vector_measure_max_fgFLOAT32(FLGR_Vector *vec, fgFLOAT32 *max);
  void flgr_vector_measure_max_fgFLOAT64(FLGR_Vector *vec, fgFLOAT64 *max);







#endif

#ifdef __cplusplus
}
#endif




